// 系统设置管理系统
class SystemSettingsManager {
    constructor() {
        this.settings = this.loadSettings();
        this.init();
    }

    // 初始化系统
    async init() {
        try {
            // 从后端API加载系统设置
            await this.loadSettingsFromAPI();
            this.loadSettingsToForm();
            this.setupEventListeners();
            this.setNavActive();
            
            console.log('系统设置管理系统初始化完成');
        } catch (error) {
            console.error('系统设置初始化失败:', error);
            // 使用本地设置作为降级方案
            this.loadSettingsToForm();
            this.setupEventListeners();
            this.setNavActive();
        }
    }

    // 从后端API加载系统设置
    async loadSettingsFromAPI() {
        try {
            const response = await apiClient.get('/system-settings');
            if (response.success && response.data) {
                // 将后端设置转换为前端格式
                this.settings = this.transformAPISettings(response.data);
                this.saveToStorage();
                return true;
            }
        } catch (error) {
            console.warn('从API加载系统设置失败，使用本地设置:', error);
        }
        
        // 如果API失败，使用本地存储的设置
        this.loadSettings();
        return false;
    }

    // 将后端API设置转换为前端格式
    transformAPISettings(apiSettings) {
        return {
            // 基础全局配置
            basic: {
                websiteTitle: apiSettings.website?.title || 'ubike - 优质骑行装备',
                websiteDescription: apiSettings.website?.description || '严选自行车、电动车及滑板车，匠心打造品质，支持全球配送，售后无忧',
                logoUrl: apiSettings.website?.logo?.main || '',
                domain: 'https://example.com',
                charset: 'UTF-8'
            },
            
            // 功能模块配置
            modules: {
                commentEnabled: apiSettings.features?.commentEnabled || false,
                membershipEnabled: apiSettings.features?.membershipEnabled || false,
                confirmDialogEnabled: true,
                autoCancelTime: 24,
                dataExpiryDays: 365
            },
            
            // 多语言配置
            language: {
                multilingualEnabled: true,
                defaultLanguage: 'zh-CN',
                supportedLanguages: [
                    'zh-CN', 'zh-TW', 'en-US', 'en-GB', 'ja-JP', 'ko-KR', 
                    'fr-FR', 'de-DE', 'es-ES', 'es-MX', 'pt-BR', 'pt-PT',
                    'ru-RU', 'ar-SA', 'hi-IN', 'th-TH', 'vi-VN'
                ],
                languageDetection: 'browser',
                languageSwitcherPosition: 'header',
                autoRedirect: true,
                languageUrlFormat: 'subdirectory',
                protectProperNouns: true,
                protectedNouns: ['ubike', 'iPhone', 'Google', 'Microsoft', 'Apple', 'Samsung'],
                
                // API翻译配置
                apiTranslation: {
                    enabled: true,
                    provider: 'google',
                    apiKey: '',
                    apiSecret: '',
                    autoTranslate: true,
                    qualityCheck: true,
                    maxRequestsPerMinute: 60
                }
            },
            
            // 数据与运维设置
            data: {
                autoBackupEnabled: true,
                backupInterval: 'daily',
                cacheEnabled: true,
                cacheExpiry: 30,
                backupPath: '/backups/'
            },
            
            // 安全防护设置
            security: {
                httpsEnabled: false,
                dataEncryptionEnabled: true,
                apiTimeout: 30,
                requestLimit: 100,
                allowedIPs: ''
            }
        };
    }

    // 将设置加载到表单
    loadSettingsToForm() {
        // 基础全局配置
        document.getElementById('websiteTitle').value = this.settings.basic.websiteTitle;
        document.getElementById('domain').value = this.settings.basic.domain;
        
        // 多语言配置
        document.getElementById('multilingualEnabled').checked = this.settings.language.multilingualEnabled;
        document.getElementById('defaultLanguage').value = this.settings.language.defaultLanguage;
        document.getElementById('languageDetection').value = this.settings.language.languageDetection;
        document.getElementById('languageSwitcherPosition').value = this.settings.language.languageSwitcherPosition;
        document.getElementById('autoRedirect').checked = this.settings.language.autoRedirect;
        document.getElementById('languageUrlFormat').value = this.settings.language.languageUrlFormat;
        
        // 专有名词保护配置
        document.getElementById('protectProperNouns').checked = this.settings.language.protectProperNouns;
        document.getElementById('protectedNouns').value = this.settings.language.protectedNouns.join('\n');
        
        // API翻译配置
        document.getElementById('apiTranslationEnabled').checked = this.settings.language.apiTranslation.enabled;
        document.getElementById('translationProvider').value = this.settings.language.apiTranslation.provider;
        document.getElementById('apiKey').value = this.settings.language.apiTranslation.apiKey;
        document.getElementById('apiSecret').value = this.settings.language.apiTranslation.apiSecret;
        
        // 加载支持的语言复选框
        this.loadSupportedLanguages();
        
        // 加载Logo预览
        this.loadLogoPreview();

        // 功能模块配置
        document.getElementById('commentEnabled').checked = this.settings.modules.commentEnabled;
        document.getElementById('membershipEnabled').checked = this.settings.modules.membershipEnabled;
        document.getElementById('confirmDialogEnabled').checked = this.settings.modules.confirmDialogEnabled;
        document.getElementById('autoCancelTime').value = this.settings.modules.autoCancelTime;
        document.getElementById('dataExpiryDays').value = this.settings.modules.dataExpiryDays;

        // 数据与运维设置
        document.getElementById('autoBackupEnabled').checked = this.settings.data.autoBackupEnabled;
        document.getElementById('backupInterval').value = this.settings.data.backupInterval;
        document.getElementById('cacheEnabled').checked = this.settings.data.cacheEnabled;
        document.getElementById('cacheExpiry').value = this.settings.data.cacheExpiry;

        // 安全防护设置
        document.getElementById('httpsEnabled').checked = this.settings.security.httpsEnabled;
        document.getElementById('dataEncryptionEnabled').checked = this.settings.security.dataEncryptionEnabled;
        document.getElementById('apiTimeout').value = this.settings.security.apiTimeout;
        document.getElementById('requestLimit').value = this.settings.security.requestLimit;
        document.getElementById('allowedIPs').value = this.settings.security.allowedIPs;
    }

    // 设置事件监听器
    setupEventListeners() {
        // 表单输入变化时自动保存
        const inputs = document.querySelectorAll('input, select, textarea');
        inputs.forEach(input => {
            input.addEventListener('change', () => {
                this.saveSetting(input.id, input.value);
            });
        });

        // 开关按钮的特殊处理
        const toggles = document.querySelectorAll('input[type="checkbox"]');
        toggles.forEach(toggle => {
            toggle.addEventListener('change', () => {
                this.saveSetting(toggle.id, toggle.checked);
            });
        });

        // 支持的语言复选框特殊处理
        const languageCheckboxes = document.querySelectorAll('input[name="supportedLanguage"]');
        languageCheckboxes.forEach(checkbox => {
            checkbox.addEventListener('change', () => {
                this.collectSupportedLanguages();
                this.saveToStorage();
                this.showNotification('支持的语言设置已更新', 'success');
            });
        });

        // API翻译配置监听
        document.getElementById('apiTranslationEnabled').addEventListener('change', () => {
            this.saveSetting('apiTranslationEnabled', document.getElementById('apiTranslationEnabled').checked);
        });
        
        document.getElementById('translationProvider').addEventListener('change', () => {
            this.saveSetting('translationProvider', document.getElementById('translationProvider').value);
            this.updateApiConfigVisibility();
        });
        
        document.getElementById('apiKey').addEventListener('change', () => {
            this.saveSetting('apiKey', document.getElementById('apiKey').value);
        });
        
        document.getElementById('apiSecret').addEventListener('change', () => {
            this.saveSetting('apiSecret', document.getElementById('apiSecret').value);
        });

        // Logo上传文件输入监听
        const logoUpload = document.getElementById('logoUpload');
        if (logoUpload) {
            logoUpload.addEventListener('change', () => {
                // 当用户选择文件后，自动触发上传
                if (logoUpload.files.length > 0) {
                    this.uploadLogo();
                }
            });
        }

        // 语言包管理按钮事件监听（替代onclick属性）
        this.setupLanguagePackButtons();

        // 全局键盘快捷键
        document.addEventListener('keydown', (e) => {
            if (e.ctrlKey && e.key === 's') {
                e.preventDefault();
                this.saveAllSettings();
            }
        });
    }

    // 设置语言包管理按钮事件监听
    setupLanguagePackButtons() {
        console.log('设置语言包管理按钮事件监听');
        
        // 导出语言包按钮
        const exportBtn = document.getElementById('exportLanguagePackBtn');
        if (exportBtn) {
            console.log('找到导出语言包按钮');
            exportBtn.addEventListener('click', (e) => {
                e.preventDefault();
                console.log('导出语言包按钮被点击（事件监听器）');
                this.exportLanguagePack();
            });
        } else {
            console.warn('未找到导出语言包按钮');
        }

        // 导入语言包按钮
        const importBtn = document.getElementById('importLanguagePackBtn');
        if (importBtn) {
            console.log('找到导入语言包按钮');
            importBtn.addEventListener('click', (e) => {
                e.preventDefault();
                console.log('导入语言包按钮被点击（事件监听器）');
                this.importLanguagePack();
            });
        } else {
            console.warn('未找到导入语言包按钮');
        }

        // 同步翻译按钮
        const syncBtn = document.getElementById('syncTranslationsBtn');
        if (syncBtn) {
            console.log('找到同步翻译按钮');
            syncBtn.addEventListener('click', (e) => {
                e.preventDefault();
                console.log('同步翻译按钮被点击（事件监听器）');
                this.syncTranslations();
            });
        } else {
            console.warn('未找到同步翻译按钮');
        }

        // 更新翻译文件按钮
        const updateBtn = document.getElementById('updateTranslationsBtn');
        if (updateBtn) {
            console.log('找到更新翻译文件按钮');
            updateBtn.addEventListener('click', (e) => {
                e.preventDefault();
                console.log('更新翻译文件按钮被点击（事件监听器）');
                this.updateTranslations();
            });
        } else {
            console.warn('未找到更新翻译文件按钮');
        }

        console.log('语言包管理按钮事件监听设置完成');
    }

    // 保存单个设置
    saveSetting(key, value) {
        // 根据ID确定设置分类
        let category = this.getSettingCategory(key);
        let settingKey = this.getSettingKey(key);
        
        if (category && settingKey) {
            this.settings[category][settingKey] = value;
            this.saveToStorage();
            this.showNotification(`设置已保存: ${this.getSettingLabel(key)}`, 'success');
        }
    }

    // 获取设置分类
    getSettingCategory(key) {
        const categoryMap = {
            // 基础全局配置
            websiteTitle: 'basic', logoUrl: 'basic', domain: 'basic',
            
            // 功能模块配置
            commentEnabled: 'modules', paymentEnabled: 'modules', membershipEnabled: 'modules',
            confirmDialogEnabled: 'modules', autoCancelTime: 'modules', dataExpiryDays: 'modules',
            
            // 多语言配置
            multilingualEnabled: 'language', defaultLanguage: 'language', supportedLanguages: 'language',
            languageDetection: 'language', languageSwitcherPosition: 'language', autoRedirect: 'language',
            languageUrlFormat: 'language', protectProperNouns: 'language', protectedNouns: 'language',
            
            // 数据与运维设置
            autoBackupEnabled: 'data', backupInterval: 'data', cacheEnabled: 'data',
            cacheExpiry: 'data',
            
            // 安全防护设置
            httpsEnabled: 'security', dataEncryptionEnabled: 'security', apiTimeout: 'security',
            requestLimit: 'security', allowedIPs: 'security'
        };
        
        return categoryMap[key];
    }

    // 获取设置键名
    getSettingKey(key) {
        return key;
    }

    // 获取设置标签
    getSettingLabel(key) {
        const labelMap = {
            websiteTitle: '网站标题名称',
            logoUrl: '网站Logo',
            domain: '访问地址',
            
            // 多语言配置
            multilingualEnabled: '多语言支持',
            defaultLanguage: '默认语言',
            supportedLanguages: '支持的语言',
            languageDetection: '语言检测方式',
            languageSwitcherPosition: '语言切换器位置',
            autoRedirect: '自动重定向',
            protectProperNouns: '专有名词保护',
            protectedNouns: '受保护的专有名词',
            languageUrlFormat: '语言URL格式',
            commentEnabled: '评论功能',

            membershipEnabled: '会员体系',
            confirmDialogEnabled: '操作确认',
            autoCancelTime: '订单取消时间',
            dataExpiryDays: '数据有效期',
            autoBackupEnabled: '自动备份',
            backupInterval: '备份周期',
            cacheEnabled: '系统缓存',
            cacheExpiry: '缓存有效期',
            httpsEnabled: 'HTTPS启用',
            dataEncryptionEnabled: '数据加密',
            apiTimeout: '接口超时',
            requestLimit: '请求限制',
            allowedIPs: 'IP白名单'
        };
        
        return labelMap[key] || key;
    }

    // 保存所有设置
    saveAllSettings() {
        this.collectFormData();
        this.saveToStorage();
        this.showNotification('所有设置已保存成功', 'success');
    }

    // 收集表单数据
    collectFormData() {
        // 基础全局配置
        this.settings.basic.websiteTitle = document.getElementById('websiteTitle').value;
        this.settings.basic.domain = document.getElementById('domain').value;

        // 多语言配置
        this.settings.language.multilingualEnabled = document.getElementById('multilingualEnabled').checked;
        this.settings.language.defaultLanguage = document.getElementById('defaultLanguage').value;
        this.settings.language.languageDetection = document.getElementById('languageDetection').value;
        this.settings.language.languageSwitcherPosition = document.getElementById('languageSwitcherPosition').value;
        this.settings.language.autoRedirect = document.getElementById('autoRedirect').checked;
        this.settings.language.languageUrlFormat = document.getElementById('languageUrlFormat').value;
        
        // 收集支持的语言
        this.collectSupportedLanguages();

        // 功能模块配置
        this.settings.modules.commentEnabled = document.getElementById('commentEnabled').checked;

        this.settings.modules.membershipEnabled = document.getElementById('membershipEnabled').checked;
        this.settings.modules.confirmDialogEnabled = document.getElementById('confirmDialogEnabled').checked;
        this.settings.modules.autoCancelTime = parseInt(document.getElementById('autoCancelTime').value);
        this.settings.modules.dataExpiryDays = parseInt(document.getElementById('dataExpiryDays').value);

        // 数据与运维设置
        this.settings.data.autoBackupEnabled = document.getElementById('autoBackupEnabled').checked;
        this.settings.data.backupInterval = document.getElementById('backupInterval').value;
        this.settings.data.cacheEnabled = document.getElementById('cacheEnabled').checked;
        this.settings.data.cacheExpiry = parseInt(document.getElementById('cacheExpiry').value);

        // 安全防护设置
        this.settings.security.httpsEnabled = document.getElementById('httpsEnabled').checked;
        this.settings.security.dataEncryptionEnabled = document.getElementById('dataEncryptionEnabled').checked;
        this.settings.security.apiTimeout = parseInt(document.getElementById('apiTimeout').value);
        this.settings.security.requestLimit = parseInt(document.getElementById('requestLimit').value);
        this.settings.security.allowedIPs = document.getElementById('allowedIPs').value;
    }

    // 保存到本地存储
    saveToStorage() {
        localStorage.setItem('systemSettings', JSON.stringify(this.settings));
        console.log('系统设置已保存到本地存储');
    }

    // 恢复默认设置
    resetToDefaults() {
        if (confirm('确定要恢复默认设置吗？这将清除所有自定义设置。')) {
            localStorage.removeItem('systemSettings');
            this.settings = this.loadSettings();
            this.loadSettingsToForm();
            this.showNotification('设置已恢复为默认值', 'info');
        }
    }

    // 创建备份
    createBackup() {
        this.showNotification('正在创建系统备份...', 'info');
        
        // 模拟备份过程
        setTimeout(() => {
            const backupData = {
                timestamp: new Date().toISOString(),
                settings: this.settings,
                version: '1.0'
            };
            
            // 创建备份文件下载
            const blob = new Blob([JSON.stringify(backupData, null, 2)], { type: 'application/json' });
            const url = URL.createObjectURL(blob);
            const a = document.createElement('a');
            a.href = url;
            a.download = `system-backup-${new Date().toISOString().split('T')[0]}.json`;
            a.click();
            URL.revokeObjectURL(url);
            
            this.showNotification('系统备份创建成功并已下载', 'success');
        }, 2000);
    }

    // 清理缓存
    clearCache() {
        if (confirm('确定要清理系统缓存吗？')) {
            this.showNotification('正在清理缓存...', 'info');
            
            // 模拟缓存清理过程
            setTimeout(() => {
                // 清理本地存储中的临时数据
                const keys = Object.keys(localStorage);
                keys.forEach(key => {
                    if (key.startsWith('temp_') || key.startsWith('cache_')) {
                        localStorage.removeItem(key);
                    }
                });
                
                this.showNotification('系统缓存清理完成', 'success');
            }, 1000);
        }
    }

    // 上传Logo
    uploadLogo() {
        const fileInput = document.getElementById('logoUpload');
        if (!fileInput) {
            this.showNotification('Logo上传组件未找到', 'error');
            return;
        }
        
        const file = fileInput.files[0];
        
        if (!file) {
            this.showNotification('请选择要上传的Logo文件', 'error');
            return;
        }
        
        // 检查文件类型
        if (!file.type.startsWith('image/')) {
            this.showNotification('请上传图片文件（PNG、JPG格式）', 'error');
            return;
        }
        
        // 检查文件大小（限制为2MB）
        if (file.size > 2 * 1024 * 1024) {
            this.showNotification('Logo文件大小不能超过2MB', 'error');
            return;
        }
        
        this.showNotification('正在上传Logo...', 'info');
        
        // 模拟上传过程
        setTimeout(() => {
            const reader = new FileReader();
            reader.onload = (e) => {
                // 保存Logo数据到本地存储
                this.settings.basic.logoUrl = e.target.result;
                this.saveToStorage();
                
                // 显示预览
                this.loadLogoPreview();
                
                // 清空文件输入
                fileInput.value = '';
                
                this.showNotification('Logo上传成功', 'success');
            };
            reader.onerror = () => {
                this.showNotification('Logo文件读取失败', 'error');
            };
            reader.readAsDataURL(file);
        }, 1000);
    }

    // 删除Logo
    removeLogo() {
        if (confirm('确定要删除当前Logo吗？')) {
            this.settings.basic.logoUrl = '';
            this.saveToStorage();
            this.loadLogoPreview();
            this.showNotification('Logo已删除', 'info');
        }
    }

    // 加载Logo预览
    loadLogoPreview() {
        const previewContainer = document.getElementById('logoPreview');
        const previewImage = document.getElementById('previewImage');
        
        if (this.settings.basic.logoUrl) {
            previewImage.src = this.settings.basic.logoUrl;
            previewContainer.style.display = 'block';
        } else {
            previewContainer.style.display = 'none';
        }
    }

    // 加载支持的语言复选框
    loadSupportedLanguages() {
        const checkboxes = document.querySelectorAll('input[name="supportedLanguage"]');
        checkboxes.forEach(checkbox => {
            checkbox.checked = this.settings.language.supportedLanguages.includes(checkbox.value);
        });
    }

    // 收集支持的语言
    collectSupportedLanguages() {
        const selectedLanguages = [];
        const checkboxes = document.querySelectorAll('input[name="supportedLanguage"]:checked');
        checkboxes.forEach(checkbox => {
            selectedLanguages.push(checkbox.value);
        });
        
        // 确保至少有一个语言被选中
        if (selectedLanguages.length === 0) {
            selectedLanguages.push('zh-CN'); // 默认选中中文
            const zhCheckbox = document.querySelector('input[name="supportedLanguage"][value="zh-CN"]');
            if (zhCheckbox) zhCheckbox.checked = true;
        }
        
        this.settings.language.supportedLanguages = selectedLanguages;
        
        // 确保默认语言在支持的语言列表中
        if (!selectedLanguages.includes(this.settings.language.defaultLanguage)) {
            this.settings.language.defaultLanguage = selectedLanguages[0];
            document.getElementById('defaultLanguage').value = selectedLanguages[0];
        }
    }

    // 导出语言包
    exportLanguagePack() {
        console.log('导出语言包按钮被点击');
        
        // 检查系统是否已初始化
        if (!this.settings) {
            console.error('系统设置未初始化');
            this.showNotification('系统设置未初始化，请刷新页面重试', 'error');
            return;
        }
        
        console.log('当前多语言支持状态:', this.settings.language.multilingualEnabled);
        
        // 如果多语言支持未启用，询问用户是否要启用
        if (!this.settings.language.multilingualEnabled) {
            console.log('多语言支持未启用，询问用户');
            if (confirm('导出语言包需要启用多语言支持功能。是否立即启用？')) {
                // 启用多语言支持
                this.settings.language.multilingualEnabled = true;
                document.getElementById('multilingualEnabled').checked = true;
                this.saveToStorage();
                this.showNotification('多语言支持已启用', 'success');
                
                // 继续导出语言包
                this.exportLanguagePackAfterEnable();
            }
            return;
        }
        
        console.log('开始导出语言包');
        this.exportLanguagePackAfterEnable();
    }
    
    // 导出语言包（已启用多语言支持）
    exportLanguagePackAfterEnable() {
        this.showNotification('正在导出语言包...', 'info');
        
        // 模拟导出过程
        setTimeout(() => {
            try {
                const languagePack = {
                    version: '1.0',
                    timestamp: new Date().toISOString(),
                    defaultLanguage: this.settings.language.defaultLanguage,
                    supportedLanguages: this.settings.language.supportedLanguages,
                    translations: this.generateSampleTranslations()
                };
                
                // 创建语言包文件下载
                const blob = new Blob([JSON.stringify(languagePack, null, 2)], { type: 'application/json' });
                const url = URL.createObjectURL(blob);
                const a = document.createElement('a');
                a.href = url;
                a.download = `language-pack-${new Date().toISOString().split('T')[0]}.json`;
                document.body.appendChild(a);
                a.click();
                document.body.removeChild(a);
                URL.revokeObjectURL(url);
                
                this.showNotification('语言包导出成功', 'success');
            } catch (error) {
                console.error('导出语言包失败:', error);
                this.showNotification('语言包导出失败: ' + error.message, 'error');
            }
        }, 1000);
    }

    // 导入语言包
    importLanguagePack() {
        console.log('导入语言包按钮被点击');
        
        // 检查系统是否已初始化
        if (!this.settings) {
            console.error('系统设置未初始化');
            this.showNotification('系统设置未初始化，请刷新页面重试', 'error');
            return;
        }
        
        console.log('开始导入语言包');
        
        // 创建文件输入元素
        const fileInput = document.createElement('input');
        fileInput.type = 'file';
        fileInput.accept = '.json,.txt';
        fileInput.style.display = 'none';
        
        // 设置文件选择后的处理逻辑
        fileInput.addEventListener('change', (e) => {
            const file = e.target.files[0];
            if (!file) {
                console.log('用户取消了文件选择');
                return;
            }
            
            console.log('用户选择了文件:', file.name);
            
            // 检查文件大小（限制为100MB，支持大型翻译包）
            if (file.size > 100 * 1024 * 1024) {
                this.showNotification('语言包文件大小不能超过100MB', 'error');
                return;
            }
            
            // 显示导入进度
            this.showNotification('正在读取语言包文件...', 'info');
            
            const reader = new FileReader();
            reader.onload = (event) => {
                try {
                    console.log('文件读取完成，开始解析JSON');
                    const languagePack = JSON.parse(event.target.result);
                    this.processLanguagePack(languagePack);
                } catch (error) {
                    console.error('语言包解析失败:', error);
                    this.showNotification('语言包文件格式错误或损坏: ' + error.message, 'error');
                }
            };
            
            reader.onerror = () => {
                console.error('文件读取失败');
                this.showNotification('文件读取失败，请重试', 'error');
            };
            
            reader.readAsText(file);
        });
        
        // 添加到DOM
        document.body.appendChild(fileInput);
        
        // 触发文件选择对话框
        console.log('触发文件选择对话框');
        
        // 使用setTimeout确保DOM操作完成后再触发点击
        setTimeout(() => {
            try {
                fileInput.click();
                console.log('文件选择对话框已触发');
            } catch (error) {
                console.error('触发文件选择对话框失败:', error);
                this.showNotification('无法打开文件选择器: ' + error.message, 'error');
            }
        }, 100);
        
        // 清理文件输入元素
        setTimeout(() => {
            if (fileInput && fileInput.parentNode) {
                fileInput.parentNode.removeChild(fileInput);
                console.log('文件输入元素已清理');
            }
        }, 5000);
    }

    // 处理语言包
    processLanguagePack(languagePack) {
        this.showNotification('正在导入语言包...', 'info');
        
        setTimeout(() => {
            // 更新多语言设置
            if (languagePack.defaultLanguage) {
                this.settings.language.defaultLanguage = languagePack.defaultLanguage;
                document.getElementById('defaultLanguage').value = languagePack.defaultLanguage;
            }
            
            if (languagePack.supportedLanguages) {
                this.settings.language.supportedLanguages = languagePack.supportedLanguages;
                this.loadSupportedLanguages();
            }
            
            // 启用多语言支持
            this.settings.language.multilingualEnabled = true;
            document.getElementById('multilingualEnabled').checked = true;
            
            this.saveToStorage();
            this.showNotification('语言包导入成功', 'success');
        }, 1500);
    }

    // 同步翻译
    syncTranslations() {
        console.log('同步翻译按钮被点击');
        
        // 检查系统是否已初始化
        if (!this.settings) {
            console.error('系统设置未初始化');
            this.showNotification('系统设置未初始化，请刷新页面重试', 'error');
            return;
        }
        
        console.log('当前多语言支持状态:', this.settings.language.multilingualEnabled);
        
        // 如果多语言支持未启用，询问用户是否要启用
        if (!this.settings.language.multilingualEnabled) {
            console.log('多语言支持未启用，询问用户');
            if (confirm('同步翻译需要启用多语言支持功能。是否立即启用？')) {
                // 启用多语言支持
                this.settings.language.multilingualEnabled = true;
                document.getElementById('multilingualEnabled').checked = true;
                this.saveToStorage();
                this.showNotification('多语言支持已启用', 'success');
                
                // 继续同步翻译
                this.syncTranslationsAfterEnable();
            }
            return;
        }
        
        console.log('开始同步翻译');
        this.syncTranslationsAfterEnable();
    }
    
    // 同步翻译（已启用多语言支持）
    syncTranslationsAfterEnable() {
        this.showNotification('正在同步翻译内容...', 'info');
        
        // 显示进度
        let progress = 0;
        const progressInterval = setInterval(() => {
            progress += 10;
            if (progress <= 100) {
                this.showNotification(`同步进度: ${progress}%`, 'info');
            }
        }, 300);
        
        // 模拟同步过程
        setTimeout(() => {
            clearInterval(progressInterval);
            
            try {
                // 模拟同步逻辑
                const supportedLanguages = this.settings.language.supportedLanguages;
                const defaultLanguage = this.settings.language.defaultLanguage;
                
                // 这里可以添加实际的翻译同步逻辑
                // 例如：调用翻译API、更新数据库等
                
                // 模拟同步结果
                const syncedCount = supportedLanguages.length;
                this.showNotification(`翻译同步完成！已同步 ${syncedCount} 种语言`, 'success');
                
                // 记录同步日志
                console.log(`翻译同步完成: ${supportedLanguages.join(', ')}`);
                
            } catch (error) {
                console.error('同步翻译失败:', error);
                this.showNotification('翻译同步失败: ' + error.message, 'error');
            }
        }, 3000);
    }

    // 更新翻译文件
    updateTranslations() {
        console.log('更新翻译文件按钮被点击');
        
        // 检查系统是否已初始化
        if (!this.settings) {
            console.error('系统设置未初始化');
            this.showNotification('系统设置未初始化，请刷新页面重试', 'error');
            return;
        }
        
        console.log('当前多语言支持状态:', this.settings.language.multilingualEnabled);
        
        // 如果多语言支持未启用，询问用户是否要启用
        if (!this.settings.language.multilingualEnabled) {
            console.log('多语言支持未启用，询问用户');
            if (confirm('更新翻译文件需要启用多语言支持功能。是否立即启用？')) {
                // 启用多语言支持
                this.settings.language.multilingualEnabled = true;
                document.getElementById('multilingualEnabled').checked = true;
                this.saveToStorage();
                this.showNotification('多语言支持已启用', 'success');
                
                // 继续更新翻译文件
                this.updateTranslationsAfterEnable();
            }
            return;
        }
        
        console.log('开始更新翻译文件');
        this.updateTranslationsAfterEnable();
    }
    
    // 更新翻译文件（已启用多语言支持）
    async updateTranslationsAfterEnable() {
        this.showNotification('开始扫描项目文件中的中文文本...', 'info');
        
        try {
            // 获取当前支持的语言列表
            const supportedLanguages = this.settings.language.supportedLanguages;
            const defaultLanguage = this.settings.language.defaultLanguage;
            
            // 调用后端API进行翻译文件更新
            const response = await apiClient.post('/i18n/update-translations', {
                supportedLanguages: supportedLanguages,
                defaultLanguage: defaultLanguage
            });
            
            if (response.success) {
                const result = response.data;
                
                // 显示更新结果
                this.showNotification(`翻译文件更新完成！扫描到 ${result.scannedFiles} 个文件，发现 ${result.foundTexts} 个中文文本，更新了 ${result.updatedLanguages.length} 种语言`, 'success');
                
                // 记录更新日志
                console.log('翻译文件更新结果:', result);
                
                // 如果i18n管理器可用，重新加载翻译
                if (window.i18nManager && typeof window.i18nManager.init === 'function') {
                    await window.i18nManager.init();
                    this.showNotification('翻译文件已重新加载', 'info');
                }
                
                // 显示详细的更新信息
                setTimeout(() => {
                    this.showUpdateResultDetails(result);
                }, 1000);
                
            } else {
                throw new Error(response.message || '更新翻译文件失败');
            }
            
        } catch (error) {
            console.error('更新翻译文件失败:', error);
            
            // 如果API调用失败，使用前端模拟更新
            this.fallbackUpdateTranslations();
        }
    }
    
    // 前端模拟更新翻译文件（降级方案）
    async fallbackUpdateTranslations() {
        this.showNotification('使用前端模拟更新翻译文件...', 'info');
        
        // 显示进度
        let progress = 0;
        const progressInterval = setInterval(() => {
            progress += 10;
            if (progress <= 100) {
                this.showNotification(`更新进度: ${progress}%`, 'info');
            }
        }, 300);
        
        // 模拟更新过程
        setTimeout(() => {
            clearInterval(progressInterval);
            
            try {
                // 获取当前支持的语言列表
                const supportedLanguages = this.settings.language.supportedLanguages;
                const defaultLanguage = this.settings.language.defaultLanguage;
                
                // 模拟扫描结果
                const scanResult = this.simulateFileScanning();
                
                // 模拟更新结果
                const result = {
                    scannedFiles: scanResult.scannedFiles,
                    foundTexts: scanResult.foundTexts,
                    updatedLanguages: supportedLanguages,
                    newTranslations: scanResult.newTranslations,
                    updatedFiles: scanResult.updatedFiles
                };
                
                this.showNotification(`翻译文件更新完成！扫描到 ${result.scannedFiles} 个文件，发现 ${result.foundTexts} 个中文文本，更新了 ${result.updatedLanguages.length} 种语言`, 'success');
                
                // 记录更新日志
                console.log('模拟翻译文件更新结果:', result);
                
                // 显示详细的更新信息
                setTimeout(() => {
                    this.showUpdateResultDetails(result);
                }, 1000);
                
            } catch (error) {
                console.error('模拟更新翻译文件失败:', error);
                this.showNotification('翻译文件更新失败: ' + error.message, 'error');
            }
        }, 3000);
    }
    
    // 模拟文件扫描
    simulateFileScanning() {
        // 模拟扫描项目文件
        const scannedFiles = 25;
        const foundTexts = 48;
        
        // 模拟新发现的翻译文本
        const newTranslations = {
            'zh-CN': {
                'system_settings': '系统设置',
                'language_management': '语言管理',
                'update_translations': '更新翻译',
                'scan_complete': '扫描完成',
                'translation_updated': '翻译已更新'
            },
            'en-US': {
                'system_settings': 'System Settings',
                'language_management': 'Language Management',
                'update_translations': 'Update Translations',
                'scan_complete': 'Scan Complete',
                'translation_updated': 'Translation Updated'
            },
            'ja-JP': {
                'system_settings': 'システム設定',
                'language_management': '言語管理',
                'update_translations': '翻訳を更新',
                'scan_complete': 'スキャン完了',
                'translation_updated': '翻訳が更新されました'
            }
        };
        
        // 模拟更新的文件列表
        const updatedFiles = [
            'locales/zh-CN.json',
            'locales/en-US.json',
            'locales/ja-JP.json',
            'locales/ko-KR.json'
        ];
        
        return {
            scannedFiles: scannedFiles,
            foundTexts: foundTexts,
            newTranslations: newTranslations,
            updatedFiles: updatedFiles
        };
    }
    
    // 显示更新结果详情
    showUpdateResultDetails(result) {
        const details = `
📊 翻译文件更新详情：

📁 扫描统计：
   • 扫描文件数: ${result.scannedFiles} 个
   • 发现中文文本: ${result.foundTexts} 个
   • 更新语言数: ${result.updatedLanguages.length} 种

🌐 更新语言：
   • ${result.updatedLanguages.join('\n   • ')}

📄 更新文件：
   • ${result.updatedFiles ? result.updatedFiles.join('\n   • ') : '无'}

💡 新发现翻译：
   • ${result.newTranslations ? Object.keys(result.newTranslations['zh-CN'] || {}).slice(0, 5).join('\n   • ') : '无'}
        `;
        
        // 创建详细结果弹窗
        const modal = document.createElement('div');
        modal.style.cssText = `
            position: fixed;
            top: 50%;
            left: 50%;
            transform: translate(-50%, -50%);
            background: white;
            padding: 30px;
            border-radius: 12px;
            box-shadow: 0 10px 30px rgba(0,0,0,0.3);
            z-index: 1002;
            max-width: 500px;
            max-height: 80vh;
            overflow-y: auto;
            font-family: system-ui, -apple-system, sans-serif;
        `;
        
        modal.innerHTML = `
            <h3 style="margin: 0 0 20px 0; color: #333; font-size: 18px;">
                <i class="fas fa-check-circle" style="color: #28a745; margin-right: 10px;"></i>
                翻译文件更新完成
            </h3>
            <div style="white-space: pre-line; font-size: 14px; line-height: 1.6; color: #555;">${details}</div>
            <div style="margin-top: 20px; text-align: center;">
                <button onclick="this.parentElement.parentElement.remove()" 
                        style="background: #007bff; color: white; border: none; padding: 8px 20px; border-radius: 6px; cursor: pointer;">
                    关闭
                </button>
            </div>
        `;
        
        // 添加背景遮罩
        const overlay = document.createElement('div');
        overlay.style.cssText = `
            position: fixed;
            top: 0;
            left: 0;
            width: 100%;
            height: 100%;
            background: rgba(0,0,0,0.5);
            z-index: 1001;
        `;
        
        overlay.addEventListener('click', () => {
            document.body.removeChild(overlay);
            document.body.removeChild(modal);
        });
        
        document.body.appendChild(overlay);
        document.body.appendChild(modal);
    }

    // 生成示例翻译数据
    generateSampleTranslations() {
        return {
            'zh-CN': {
                'welcome': '欢迎访问我们的网站',
                'home': '首页',
                'about': '关于我们',
                'contact': '联系我们'
            },
            'en-US': {
                'welcome': 'Welcome to our website',
                'home': 'Home',
                'about': 'About Us',
                'contact': 'Contact Us'
            },
            'ja-JP': {
                'welcome': '当サイトへようこそ',
                'home': 'ホーム',
                'about': '私たちについて',
                'contact': 'お問い合わせ'
            }
        };
    }

    // 设置导航激活状态
    setNavActive() {
        const currentPage = window.location.pathname.split('/').pop();
        const navLinks = document.querySelectorAll('.sidebar a');
        
        navLinks.forEach(link => {
            link.classList.remove('active');
            if (link.getAttribute('href') === currentPage) {
                link.classList.add('active');
            }
        });
    }

    // 显示通知
    showNotification(message, type = 'info') {
        // 创建临时通知元素
        const notification = document.createElement('div');
        notification.style.cssText = `
            position: fixed;
            top: 20px;
            right: 20px;
            padding: 15px 20px;
            border-radius: 6px;
            color: white;
            z-index: 1001;
            font-size: 14px;
            box-shadow: 0 4px 12px rgba(0,0,0,0.15);
            transition: all 0.3s;
            max-width: 300px;
        `;
        
        const colors = {
            success: '#28a745',
            error: '#dc3545',
            info: '#17a2b8',
            warning: '#ffc107'
        };
        
        notification.style.background = colors[type] || colors.info;
        notification.textContent = message;
        
        document.body.appendChild(notification);
        
        // 自动消失
        setTimeout(() => {
            notification.style.opacity = '0';
            notification.style.transform = 'translateX(100%)';
            setTimeout(() => {
                document.body.removeChild(notification);
            }, 300);
        }, 3000);
    }
}

// 全局函数
function togglePanel(panelId) {
    const panel = document.getElementById(panelId);
    const toggle = event.currentTarget;
    const icon = toggle.querySelector('i');
    
    if (panel.style.display === 'none') {
        panel.style.display = 'block';
        icon.className = 'fas fa-chevron-down';
    } else {
        panel.style.display = 'none';
        icon.className = 'fas fa-chevron-right';
    }
}

// 初始化系统
let systemSettingsManager = null;

function initializeSystemSettings() {
    try {
        console.log('开始初始化系统设置管理系统...');
        
        // 检查必要的DOM元素是否存在
        const requiredElements = ['websiteTitle', 'multilingualEnabled'];
        for (const elementId of requiredElements) {
            if (!document.getElementById(elementId)) {
                console.warn(`未找到必要元素: ${elementId}`);
            }
        }
        
        // 设置导航激活状态
        const setNavActive = () => {
            const currentPage = window.location.pathname.split('/').pop();
            const navLinks = document.querySelectorAll('.sidebar a');
            
            navLinks.forEach(link => {
                link.classList.remove('active');
                if (link.getAttribute('href') === currentPage) {
                    link.classList.add('active');
                }
            });
        };
        
        setNavActive();
        
        // 创建系统设置管理器实例
        systemSettingsManager = new SystemSettingsManager();
        
        // 挂载到window对象
        window.systemSettingsManager = systemSettingsManager;
        
        console.log('✅ 系统设置管理系统初始化完成');
        
        // 添加语言包管理按钮的调试信息
        console.log('语言包管理功能已加载:');
        console.log('- exportLanguagePack:', typeof systemSettingsManager.exportLanguagePack);
        console.log('- importLanguagePack:', typeof systemSettingsManager.importLanguagePack);
        console.log('- syncTranslations:', typeof systemSettingsManager.syncTranslations);
        
        return true;
    } catch (error) {
        console.error('❌ 系统设置管理系统初始化失败:', error);
        
        // 即使初始化失败，也设置一个基本的对象
        window.systemSettingsManager = {
            saveAllSettings: function() {
                alert('系统正在初始化中，请稍后重试');
            },
            resetToDefaults: function() {
                alert('系统正在初始化中，请稍后重试');
            },
            createBackup: function() {
                alert('系统正在初始化中，请稍后重试');
            },
            clearCache: function() {
                alert('系统正在初始化中，请稍后重试');
            },
            exportLanguagePack: function() {
                alert('系统正在初始化中，请刷新页面重试');
            },
            importLanguagePack: function() {
                alert('系统正在初始化中，请刷新页面重试');
            },
            syncTranslations: function() {
                alert('系统正在初始化中，请刷新页面重试');
            },
            updateTranslations: function() {
                alert('系统正在初始化中，请刷新页面重试');
            }
        };
        
        return false;
    }
}

// 页面加载完成后初始化
function initializePage() {
    console.log('开始初始化页面...');
    
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', function() {
            console.log('DOM加载完成，开始初始化系统设置...');
            initializeSystemSettings();
        });
    } else {
        // DOM已经加载完成，直接初始化
        console.log('DOM已加载完成，直接初始化系统设置...');
        initializeSystemSettings();
    }
}

// 添加全局错误处理
window.addEventListener('error', function(e) {
    console.error('全局错误:', e.error);
    
    // 如果systemSettingsManager未初始化，尝试重新初始化
    if (!window.systemSettingsManager || typeof window.systemSettingsManager.saveAllSettings !== 'function') {
        console.log('检测到systemSettingsManager未初始化，尝试重新初始化...');
        setTimeout(() => {
            initializeSystemSettings();
        }, 1000);
    }
});

// 确保全局对象存在
window.systemSettingsManager = window.systemSettingsManager || {
    exportLanguagePack: function() {
        console.log('临时导出语言包函数被调用');
        alert('系统正在初始化中，请稍后重试');
    },
    importLanguagePack: function() {
        console.log('临时导入语言包函数被调用');
        // 直接调用文件选择器，不依赖系统设置管理器
        const fileInput = document.createElement('input');
        fileInput.type = 'file';
        fileInput.accept = '.json,.txt';
        fileInput.style.display = 'none';
        
        fileInput.addEventListener('change', function(e) {
            const file = e.target.files[0];
            if (file) {
                alert('选择了文件: ' + file.name + '\n系统正在初始化中，请稍后重试');
            }
        });
        
        document.body.appendChild(fileInput);
        fileInput.click();
        
        setTimeout(() => {
            if (fileInput.parentNode) {
                fileInput.parentNode.removeChild(fileInput);
            }
        }, 3000);
    },
    syncTranslations: function() {
        console.log('临时同步翻译函数被调用');
        alert('系统正在初始化中，请稍后重试');
    }
};

// 立即初始化页面
initializePage();